package com.hbnu.system.service.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hbnu.system.mapper.PatenttypeMapper;
import com.hbnu.system.model.entity.Patent_Type;
import com.hbnu.system.model.vo.ChildrenNameId;
import com.hbnu.system.model.vo.NameId;
import com.hbnu.system.service.IPatentTypeService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class PatentTypeServiceImpl  extends ServiceImpl<PatenttypeMapper, Patent_Type> implements IPatentTypeService {

    @Override
    public List<NameId> getCascadingData() {
        // 用于存储三级分类数据的映射
        Map<Integer, ChildrenNameId> level1Map = new HashMap<>();
        Map<Integer, ChildrenNameId> level2Map = new HashMap<>();

        // 先查询所有专利类型数据
        List<Patent_Type> patentTypeList = baseMapper.selectList(Wrappers.lambdaQuery(Patent_Type.class));

        // 构建第一级分类（Type1）
        for (Patent_Type type : patentTypeList) {
            int type1Id = type.getType1ID();
            if (!level1Map.containsKey(type1Id)) {
                ChildrenNameId level1Item = new ChildrenNameId(type.getPatentType1(), type1Id);
                level1Map.put(type1Id, level1Item);
            }
        }

        // 构建第二级分类（Type2）并关联到第一级
        for (Patent_Type type : patentTypeList) {
            int type1Id = type.getType1ID();
            int type2Id = type.getType2ID();

            // 跳过Type2ID为0的情况（无第二级分类）
            if (type2Id == 0) continue;

            if (!level2Map.containsKey(type2Id)) {
                ChildrenNameId level2Item = new ChildrenNameId(type.getPatentType2(), type2Id);
                level2Map.put(type2Id, level2Item);

                // 将Type2添加到对应的Type1下
                ChildrenNameId level1Item = level1Map.get(type1Id);
                level1Item.getChildren().add(level2Item);
            }
        }

        // 构建第三级分类（Type3）并关联到第二级
        for (Patent_Type type : patentTypeList) {
            int type2Id = type.getType2ID();
            int type3Id = type.getType3ID();

            // 跳过Type3ID为0的情况（自定义类型）
            if (type3Id == 0) continue;

            // 确保该Type2存在
            if (level2Map.containsKey(type2Id)) {
                NameId level3Item = new NameId(type.getPatentType3(), type3Id);
                level2Map.get(type2Id).getChildren().add(level3Item);
            }
        }

        // 处理特殊情况：Type1为3或4（技术实施许可类、技术转让类），没有子分类
        for (Patent_Type type : patentTypeList) {
            if (type.getType1ID() == 3 || type.getType1ID() == 4) {
                ChildrenNameId level1Item = level1Map.get(type.getType1ID());
                // 如果没有子分类，将ChildrenNameId转换为普通NameId
                if (level1Item.getChildren().isEmpty()) {
                    NameId simpleLevel1Item = new NameId(level1Item.getLabel(), level1Item.getValue());
                    level1Map.put(type.getType1ID(), new ChildrenNameId(simpleLevel1Item.getLabel(), simpleLevel1Item.getValue()));
                }
            }
        }

        // 过滤掉没有子节点的ChildrenNameId，转换为普通NameId
        List<NameId> result = new ArrayList<>();
        for (ChildrenNameId level1Item : level1Map.values()) {
            if (level1Item.getChildren().isEmpty()) {
                result.add(new NameId(level1Item.getLabel(), level1Item.getValue()));
            } else {
                // 递归处理子节点，移除空的ChildrenNameId
                List<NameId> filteredChildren = new ArrayList<>();
                for (NameId child : level1Item.getChildren()) {
                    if (child instanceof ChildrenNameId) {
                        ChildrenNameId childWithChildren = (ChildrenNameId) child;
                        if (!childWithChildren.getChildren().isEmpty()) {
                            filteredChildren.add(childWithChildren);
                        } else {
                            filteredChildren.add(new NameId(child.getLabel(), child.getValue()));
                        }
                    } else {
                        filteredChildren.add(child);
                    }
                }
                level1Item.setChildren(filteredChildren);
                result.add(level1Item);
            }
        }

        return result;
    }


//    @Override
//    public List<NameId> getCascadingData() {
//        ArrayList<NameId> result = new ArrayList<>();
//        ArrayList<NameId> midlist = new ArrayList<>();
//        ArrayList<NameId> lastlist = new ArrayList<>();
//
//        HashMap<String, Integer> types_map1 = new HashMap<>();
//        HashMap<String, Integer> types_map2 = new HashMap<>();
//        HashMap<String, Integer> types_map3 = new HashMap<>();
//
//        List<Patent_Type> patent_typelists = baseMapper.selectList(Wrappers.lambdaQuery(Patent_Type.class));
//
//        for (Patent_Type type : patent_typelists) {
//            types_map1.put(type.getPatentType1(),type.getType1ID());
//            types_map2.put(type.getPatentType2(),type.getType2ID());
//            types_map3.put(type.getPatentType3(),type.getType3ID());
//        }
//
//        for (Map.Entry<String,Integer> entry : types_map3.entrySet()) {
//            if(entry.getValue() != 0) {
//                NameId nameId = new NameId(entry.getKey(), entry.getValue());
//                lastlist.add(nameId);
//            }
//        }
//
//        for (Map.Entry<String,Integer> entry : types_map2.entrySet()) {
//                if(entry.getValue() > 15){
//                    NameId nameId = new NameId(entry.getKey(), entry.getValue());
//                    midlist.add(nameId);
//                }else {
//                    if(entry.getValue() != 0){
//                        ChildrenNameId childrenNameId = new ChildrenNameId(entry.getKey(), entry.getValue());
//                        for (NameId nameId:lastlist) {
//                            childrenNameId.getChildren().add(nameId);
//                        }
//                        midlist.add(childrenNameId);
//                    }
//
//                }
//        }
//
//        for (Map.Entry<String,Integer> entry : types_map1.entrySet()) {
//            if (entry.getValue() == 3 || entry.getValue() == 4){
//                NameId nameId = new NameId(entry.getKey(), entry.getValue());
//                result.add(nameId);
//            }else {
//                ChildrenNameId childrenNameId = new ChildrenNameId(entry.getKey(), entry.getValue());
//                for (NameId nameId : midlist) {
//                    if(baseMapper.selectList(Wrappers.lambdaQuery(Patent_Type.class)
//                            .eq(Patent_Type::getType2ID,nameId.getValue())).get(0).getConnectionID1() == entry.getValue()){
//                        childrenNameId.getChildren().add(nameId);
//                        result.add(childrenNameId);
//                    }
//                }
//            }
//        }
//        HashSet<NameId> nameIds = new HashSet<>(result);
//        result = new ArrayList<>(nameIds);
//
//
//        return result;
//
//    }
}
